JavaScript Eş Zamanlı Veri Yapısı Senkronizasyonu: Thread-Safe Koleksiyonlar

Geleneksel olarak tek iş parçacıklı (single-threaded) bir dil olarak bilinen JavaScript, eş zamanlılığın kritik olduğu senaryolarda giderek daha fazla kullanılmaktadır. Web Worker'ların ve Atomics API'nin ortaya çıkmasıyla birlikte, geliştiriciler artık performansı ve yanıt verebilirliği artırmak için paralel işlemeden yararlanabilirler. Ancak bu güç, paylaşılan belleği yönetme ve uygun senkronizasyon yoluyla veri tutarlılığını sağlama sorumluluğunu da beraberinde getirir. Bu makale, JavaScript'teki eş zamanlı veri yapılarının dünyasına dalarak thread-safe (iş parçacığı güvenli) koleksiyonlar oluşturma tekniklerini araştırmaktadır.

JavaScript'te Eş Zamanlılığı Anlamak

JavaScript bağlamında eş zamanlılık, birden fazla görevi görünüşte aynı anda ele alma yeteneğini ifade eder. JavaScript'in olay döngüsü (event loop) asenkron işlemleri engellemeyen (non-blocking) bir şekilde yönetirken, gerçek paralellik birden fazla iş parçacığı kullanmayı gerektirir. Web Worker'lar bu yeteneği sağlar; yoğun hesaplama gerektiren görevleri ayrı iş parçacıklarına yüklemenize olanak tanıyarak ana iş parçacığının engellenmesini önler ve akıcı bir kullanıcı deneyimi sunar. Bir web uygulamasında büyük bir veri setini işlediğiniz bir senaryo düşünün. Eş zamanlılık olmadan, kullanıcı arayüzü (UI) işleme sırasında donardı. Web Worker'lar ile işleme arka planda gerçekleşir ve UI'ın yanıt vermeye devam etmesini sağlar.

Web Worker'lar: Paralelliğin Temeli

Web Worker'lar, ana JavaScript yürütme iş parçacığından bağımsız olarak çalışan arka plan betikleridir. DOM'a sınırlı erişimleri vardır, ancak ana iş parçacığı ile mesajlaşma yoluyla iletişim kurabilirler. Bu, karmaşık hesaplamalar, veri manipülasyonu ve ağ istekleri gibi görevlerin worker iş parçacıklarına yüklenmesine olanak tanır ve ana iş parçacığını UI güncellemeleri ve kullanıcı etkileşimleri için serbest bırakır. Tarayıcıda çalışan bir video düzenleme uygulaması düşünün. Karmaşık video işleme görevleri Web Worker'lar tarafından gerçekleştirilebilir, bu da akıcı bir oynatma ve düzenleme deneyimi sağlar.

SharedArrayBuffer ve Atomics API: Paylaşılan Belleği Etkinleştirme

SharedArrayBuffer nesnesi, birden fazla worker'ın ve ana iş parçacığının aynı bellek konumuna erişmesine olanak tanır. Bu, iş parçacıkları arasında verimli veri paylaşımı ve iletişim sağlar. Ancak, paylaşılan belleğe erişim, yarış koşulları (race conditions) ve veri bozulması potansiyelini de beraberinde getirir. Atomics API, veri tutarlılığını sağlayan ve bu sorunları önleyen atomik işlemler sunar. Atomik işlemler bölünemezdir; kesintiye uğramadan tamamlanırlar ve işlemin tek bir atomik birim olarak gerçekleştirilmesini garanti ederler. Örneğin, paylaşılan bir sayacı atomik bir işlem kullanarak artırmak, birden fazla iş parçacığının birbirine müdahale etmesini önleyerek doğru sonuçlar alınmasını sağlar.

Thread-Safe Koleksiyonlara Duyulan İhtiyaç

Birden fazla iş parçacığı, uygun senkronizasyon mekanizmaları olmadan aynı veri yapısına eş zamanlı olarak eriştiğinde ve onu değiştirdiğinde, yarış koşulları ortaya çıkabilir. Yarış koşulu, bir hesaplamanın nihai sonucunun, birden fazla iş parçacığının paylaşılan kaynaklara eriştiği öngörülemeyen sıraya bağlı olduğu durumlarda meydana gelir. Bu durum veri bozulmasına, tutarsız duruma ve beklenmedik uygulama davranışlarına yol açabilir. Thread-safe koleksiyonlar, bu sorunları ortaya çıkarmadan birden fazla iş parçacığından gelen eş zamanlı erişimi yönetmek için tasarlanmış veri yapılarıdır. Yoğun eş zamanlı yük altında bile veri bütünlüğünü ve tutarlılığını sağlarlar. Birden fazla iş parçacığının hesap bakiyelerini güncellediği bir finansal uygulama düşünün. Thread-safe koleksiyonlar olmadan, işlemler kaybolabilir veya kopyalanabilir, bu da ciddi finansal hatalara yol açabilir.

Yarış Koşullarını ve Veri Yarışlarını Anlamak

Bir yarış koşulu, çok iş parçacıklı bir programın sonucunun, iş parçacıklarının yürütülme sırasının öngörülemezliğine bağlı olduğu durumlarda ortaya çıkar. Veri yarışı, birden fazla iş parçacığının aynı bellek konumuna eş zamanlı olarak eriştiği ve bu iş parçacıklarından en az birinin veriyi değiştirdiği özel bir yarış koşulu türüdür. Veri yarışları, bozuk verilere ve öngörülemeyen davranışlara yol açabilir. Örneğin, iki iş parçacığı aynı anda paylaşılan bir değişkeni artırmaya çalışırsa, araya giren işlemler nedeniyle nihai sonuç yanlış olabilir.

Standart JavaScript Dizileri Neden Thread-Safe Değildir?

Standart JavaScript dizileri doğası gereği thread-safe değildir. push, pop, splice gibi işlemler ve doğrudan dizin ataması atomik değildir. Birden fazla iş parçacığı bir diziye eş zamanlı olarak erişip onu değiştirdiğinde, veri yarışları ve yarış koşulları kolayca ortaya çıkabilir. Bu, beklenmedik sonuçlara ve veri bozulmasına yol açabilir. JavaScript dizileri tek iş parçacıklı ortamlar için uygun olsa da, uygun senkronizasyon mekanizmaları olmadan eş zamanlı programlama için önerilmezler.

JavaScript'te Thread-Safe Koleksiyonlar Oluşturma Teknikleri

JavaScript'te thread-safe koleksiyonlar oluşturmak için çeşitli teknikler kullanılabilir. Bu teknikler, kilitler, atomik işlemler ve eş zamanlı erişim için tasarlanmış özel veri yapıları gibi senkronizasyon ilkellerinin (primitives) kullanımını içerir.

Kilitler (Mutex'ler)

Bir mutex (karşılıklı dışlama), paylaşılan bir kaynağa özel erişim sağlayan bir senkronizasyon ilkelidir. Kilidi herhangi bir anda yalnızca bir iş parçacığı elinde tutabilir. Bir iş parçacığı, başka bir iş parçacığı tarafından zaten tutulan bir kilidi almaya çalıştığında, kilit serbest kalana kadar engellenir. Mutex'ler, birden fazla iş parçacığının aynı veriye eş zamanlı olarak erişmesini engelleyerek veri bütünlüğünü sağlar. JavaScript'in yerleşik bir mutex'i olmasa da, Atomics.wait ve Atomics.wake kullanılarak uygulanabilir. Paylaşılan bir banka hesabı düşünün. Bir mutex, aynı anda yalnızca bir işlemin (para yatırma veya çekme) gerçekleşmesini sağlayarak, fazla para çekme veya yanlış bakiye gibi durumları önleyebilir.

JavaScript'te Bir Mutex Uygulamak

İşte SharedArrayBuffer ve Atomics kullanarak bir mutex'in nasıl uygulanacağına dair temel bir örnek:

            
class Mutex {
 constructor(sharedArrayBuffer, index = 0) {
 this.lock = new Int32Array(sharedArrayBuffer, index * Int32Array.BYTES_PER_ELEMENT, 1);
 }

 acquire() {
 while (Atomics.compareExchange(this.lock, 0, 1, 0) !== 0) {
 Atomics.wait(this.lock, 0, 1);
 }
 }

 release() {
 Atomics.store(this.lock, 0, 0);
 Atomics.notify(this.lock, 0, 1);
 }
}

            

              
                Copy
              
            
          

Bu kod, kilit durumunu saklamak için bir SharedArrayBuffer kullanan bir Mutex sınıfı tanımlar. acquire yöntemi, Atomics.compareExchange kullanarak kilidi almaya çalışır. Kilit zaten tutuluyorsa, iş parçacığı Atomics.wait kullanarak bekler. release yöntemi kilidi serbest bırakır ve bekleyen iş parçacıklarını Atomics.notify kullanarak bilgilendirir.

Mutex'i Paylaşılan Bir Dizi ile Kullanma

            
const sab = new SharedArrayBuffer(1024);
const mutex = new Mutex(sab);
const sharedArray = new Int32Array(sab, Int32Array.BYTES_PER_ELEMENT);

// Worker thread
mutex.acquire();
try {
 sharedArray[0] += 1; // Access and modify the shared array
} finally {
 mutex.release();
}

            

              
                Copy
              
            
          

Atomik İşlemler

Atomik işlemler, tek bir birim olarak yürütülen bölünemez işlemlerdir. Atomics API, paylaşılan bellek konumlarını okumak, yazmak ve değiştirmek için bir dizi atomik işlem sunar. Bu işlemler, veriye atomik olarak erişilmesini ve değiştirilmesini garanti ederek yarış koşullarını önler. Yaygın atomik işlemler arasında Atomics.add, Atomics.sub, Atomics.and, Atomics.or, Atomics.xor, Atomics.compareExchange ve Atomics.store bulunur. Örneğin, atomik olmayan sharedArray[0]++ kullanmak yerine, 0 indeksindeki değeri atomik olarak artırmak için Atomics.add(sharedArray, 0, 1) kullanabilirsiniz.

Örnek: Atomik Sayaç

            
const sab = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
const counter = new Int32Array(sab);

// Worker thread
Atomics.add(counter, 0, 1); // Atomically increment the counter

            

              
                Copy
              
            
          

Semaforlar

Bir semafor, bir sayacı koruyarak paylaşılan bir kaynağa erişimi kontrol eden bir senkronizasyon ilkelidir. İş parçacıkları sayacı azaltarak bir semafor alabilirler. Sayaç sıfırsa, iş parçacığı başka bir iş parçacığı sayacı artırarak semaforu serbest bırakana kadar engellenir. Semaforlar, bir paylaşılan kaynağa eş zamanlı olarak erişebilecek iş parçacığı sayısını sınırlamak için kullanılabilir. Örneğin, bir semafor eş zamanlı veritabanı bağlantılarının sayısını sınırlamak için kullanılabilir. Mutex'ler gibi, semaforlar da yerleşik değildir ancak Atomics.wait ve Atomics.wake kullanılarak uygulanabilir.

Bir Semafor Uygulamak

            
class Semaphore {
 constructor(sharedArrayBuffer, initialCount = 0, index = 0) {
 this.count = new Int32Array(sharedArrayBuffer, index * Int32Array.BYTES_PER_ELEMENT, 1);
 Atomics.store(this.count, 0, initialCount);
 }

 acquire() {
 while (true) {
 const current = Atomics.load(this.count, 0);
 if (current > 0 && Atomics.compareExchange(this.count, current, current - 1, current) === current) {
 return;
 }
 Atomics.wait(this.count, 0, current);
 }
 }

 release() {
 Atomics.add(this.count, 0, 1);
 Atomics.notify(this.count, 0, 1);
 }
}

            

              
                Copy
              
            
          

Eş Zamanlı Veri Yapıları (Değişmez Veri Yapıları)

Kilitlerin ve atomik işlemlerin karmaşıklığından kaçınmanın bir yolu, değişmez (immutable) veri yapıları kullanmaktır. Değişmez veri yapıları, oluşturulduktan sonra değiştirilemezler. Bunun yerine, herhangi bir değişiklik yeni bir veri yapısının oluşturulmasıyla sonuçlanır ve orijinal veri yapısı değişmeden kalır. Bu, veri yarışları olasılığını ortadan kaldırır çünkü birden fazla iş parçacığı aynı değişmez veri yapısına herhangi bir bozulma riski olmadan güvenle erişebilir. Immutable.js gibi kütüphaneler, JavaScript için eş zamanlı programlama senaryolarında çok yardımcı olabilecek değişmez veri yapıları sağlar.

Örnek: Immutable.js Kullanımı

            
import { List } from 'immutable';

let myList = List([1, 2, 3]);

// Worker thread
const newList = myList.push(4); // Creates a new list with the added element

            

              
                Copy
              
            
          

Bu örnekte, myList değişmeden kalır ve newList güncellenmiş veriyi içerir. Bu, paylaşılan değiştirilebilir bir durum olmadığı için kilitlere veya atomik işlemlere olan ihtiyacı ortadan kaldırır.

Yazma Üzerine Kopyalama (Copy-on-Write - COW)

Yazma Üzerine Kopyalama (COW), iş parçacıklarından biri onu değiştirmeye çalışana kadar verinin birden fazla iş parçacığı arasında paylaşıldığı bir tekniktir. Bir değişiklik gerektiğinde, verinin bir kopyası oluşturulur ve değişiklik kopya üzerinde gerçekleştirilir. Bu, diğer iş parçacıklarının hala orijinal veriye erişiminin olmasını sağlar. COW, verinin sık sık okunduğu ancak nadiren değiştirildiği senaryolarda performansı artırabilir. Veri tutarlılığını sağlarken kilitleme ve atomik işlemlerin getirdiği ek yükten kaçınır. Ancak, veri yapısı büyükse veriyi kopyalamanın maliyeti önemli olabilir.

Thread-Safe Bir Kuyruk Oluşturma

Yukarıda tartışılan kavramları SharedArrayBuffer, Atomics ve bir mutex kullanarak thread-safe bir kuyruk oluşturarak gösterelim.

            
class ThreadSafeQueue {
 constructor(capacity) {
 this.capacity = capacity;
 this.buffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * (capacity + 2)); // +2 for head, tail
 this.queue = new Int32Array(this.buffer, 2 * Int32Array.BYTES_PER_ELEMENT);
 this.head = new Int32Array(this.buffer, 0, 1);
 this.tail = new Int32Array(this.buffer, Int32Array.BYTES_PER_ELEMENT, 1);
 this.mutex = new Mutex(this.buffer, 2 + capacity);

 Atomics.store(this.head, 0, 0);
 Atomics.store(this.tail, 0, 0);
 }

 enqueue(value) {
 this.mutex.acquire();
 try {
 const tail = Atomics.load(this.tail, 0);
 const head = Atomics.load(this.head, 0);
 if ((tail + 1) % this.capacity === head) {
 throw new Error("Queue is full");
 }
 this.queue[tail] = value;
 Atomics.store(this.tail, 0, (tail + 1) % this.capacity);
 } finally {
 this.mutex.release();
 }
 }

 dequeue() {
 this.mutex.acquire();
 try {
 const head = Atomics.load(this.head, 0);
 const tail = Atomics.load(this.tail, 0);
 if (head === tail) {
 throw new Error("Queue is empty");
 }
 const value = this.queue[head];
 Atomics.store(this.head, 0, (head + 1) % this.capacity);
 return value;
 } finally {
 this.mutex.release();
 }
 }
}

            

              
                Copy
              
            
          

Bu kod, sabit kapasiteli thread-safe bir kuyruk uygular. Kuyruk verilerini, baş (head) ve kuyruk (tail) işaretçilerini saklamak için bir SharedArrayBuffer kullanır. Kuyruğa erişimi korumak ve aynı anda yalnızca bir iş parçacığının kuyruğu değiştirebilmesini sağlamak için bir mutex kullanılır. enqueue ve dequeue yöntemleri, kuyruğa erişmeden önce mutex'i alır ve işlem tamamlandıktan sonra serbest bırakır.

Performans Değerlendirmeleri

Thread-safe koleksiyonlar veri bütünlüğü sağlarken, senkronizasyon mekanizmaları nedeniyle performans yükü de getirebilirler. Kilitler ve atomik işlemler, özellikle yüksek çekişme (contention) olduğunda nispeten yavaş olabilir. Thread-safe koleksiyonları kullanmanın performans etkilerini dikkatlice değerlendirmek ve çekişmeyi en aza indirmek için kodunuzu optimize etmek önemlidir. Kilitlerin kapsamını azaltmak, kilitsiz (lock-free) veri yapıları kullanmak ve veriyi bölümlemek gibi teknikler performansı artırabilir.

Kilit Çekişmesi

Kilit çekişmesi, birden fazla iş parçacığı aynı anda aynı kilidi almaya çalıştığında meydana gelir. Bu, iş parçacıkları kilidin serbest kalmasını beklerken zaman harcadığı için önemli performans düşüşüne yol açabilir. Eş zamanlı programlarda iyi performans elde etmek için kilit çekişmesini azaltmak çok önemlidir. Kilit çekişmesini azaltma teknikleri arasında ince taneli (fine-grained) kilitler kullanmak, veriyi bölümlemek ve kilitsiz veri yapıları kullanmak yer alır.

Atomik İşlem Yükü

Atomik işlemler genellikle atomik olmayan işlemlerden daha yavaştır. Ancak, eş zamanlı programlarda veri bütünlüğünü sağlamak için gereklidirler. Atomik işlemleri kullanırken, gerçekleştirilen atomik işlem sayısını en aza indirmek ve bunları yalnızca gerektiğinde kullanmak önemlidir. Güncellemeleri gruplamak (batching) ve yerel önbellekler (local caches) kullanmak gibi teknikler, atomik işlemlerin getirdiği ek yükü azaltabilir.

Paylaşılan Bellek Eş Zamanlılığına Alternatifler

Web Worker'lar, SharedArrayBuffer ve Atomics ile paylaşılan bellek eş zamanlılığı JavaScript'te paralellik elde etmek için güçlü bir yol sağlarken, aynı zamanda önemli bir karmaşıklık da getirir. Paylaşılan belleği ve senkronizasyon ilkellerini yönetmek zorlayıcı ve hataya açık olabilir. Paylaşılan bellek eş zamanlılığına alternatifler arasında mesajlaşma (message passing) ve aktör tabanlı (actor-based) eş zamanlılık bulunur.

Mesajlaşma (Message Passing)

Mesajlaşma, iş parçacıklarının birbirleriyle mesaj göndererek iletişim kurduğu bir eş zamanlılık modelidir. Her iş parçacığının kendi özel bellek alanı vardır ve veri, mesajlar içinde kopyalanarak iş parçacıkları arasında aktarılır. Mesajlaşma, iş parçacıkları belleği doğrudan paylaşmadığı için veri yarışları olasılığını ortadan kaldırır. Web Worker'lar öncelikle ana iş parçacığı ile iletişim için mesajlaşmayı kullanır.

Aktör Tabanlı Eş Zamanlılık

Aktör tabanlı eş zamanlılık, eş zamanlı görevlerin aktörler içinde kapsüllendiği bir modeldir. Bir aktör, kendi durumuna sahip olan ve diğer aktörlerle mesaj göndererek iletişim kurabilen bağımsız bir varlıktır. Aktörler mesajları sırayla işler, bu da kilitlere veya atomik işlemlere olan ihtiyacı ortadan kaldırır. Aktör tabanlı eş zamanlılık, daha yüksek bir soyutlama seviyesi sağlayarak eş zamanlı programlamayı basitleştirebilir. Akka.js gibi kütüphaneler, JavaScript için aktör tabanlı eş zamanlılık çerçeveleri sunar.

Thread-Safe Koleksiyonlar için Kullanım Alanları

Thread-safe koleksiyonlar, paylaşılan verilere eş zamanlı erişimin gerekli olduğu çeşitli senaryolarda değerlidir. Bazı yaygın kullanım alanları şunlardır:

• Gerçek zamanlı veri işleme: Birden çok kaynaktan gelen gerçek zamanlı veri akışlarını işlemek, paylaşılan veri yapılarına eş zamanlı erişim gerektirir. Thread-safe koleksiyonlar, veri tutarlılığını sağlayabilir ve veri kaybını önleyebilir. Örneğin, küresel olarak dağıtılmış bir ağ üzerinden IoT cihazlarından gelen sensör verilerini işlemek.
• Oyun geliştirme: Oyun motorları genellikle fizik simülasyonları, yapay zeka işleme ve render gibi görevleri gerçekleştirmek için birden fazla iş parçacığı kullanır. Thread-safe koleksiyonlar, bu iş parçacıklarının oyun verilerine yarış koşulları oluşturmadan eş zamanlı olarak erişip değiştirebilmesini sağlayabilir. Binlerce oyuncunun aynı anda etkileşime girdiği çok oyunculu çevrimiçi bir oyunu (MMO) hayal edin.
• Finansal uygulamalar: Finansal uygulamalar genellikle hesap bakiyelerine, işlem geçmişlerine ve diğer finansal verilere eş zamanlı erişim gerektirir. Thread-safe koleksiyonlar, işlemlerin doğru bir şekilde işlenmesini ve hesap bakiyelerinin her zaman doğru olmasını sağlayabilir. Farklı küresel pazarlardan saniyede milyonlarca işlemi işleyen yüksek frekanslı bir ticaret platformunu düşünün.
• Veri analizi: Veri analizi uygulamaları genellikle büyük veri setlerini birden fazla iş parçacığı kullanarak paralel olarak işler. Thread-safe koleksiyonlar, verilerin doğru bir şekilde işlenmesini ve sonuçların tutarlı olmasını sağlayabilir. Farklı coğrafi bölgelerden gelen sosyal medya trendlerini analiz etmeyi düşünün.
• Web sunucuları: Yüksek trafikli web uygulamalarında eş zamanlı istekleri yönetmek. Thread-safe önbellekler ve oturum yönetimi yapıları, performansı ve ölçeklenebilirliği artırabilir.

Sonuç

Eş zamanlı veri yapıları ve thread-safe koleksiyonlar, JavaScript'te sağlam ve verimli eş zamanlı uygulamalar oluşturmak için gereklidir. Geliştiriciler, paylaşılan bellek eş zamanlılığının zorluklarını anlayarak ve uygun senkronizasyon mekanizmalarını kullanarak, performansı ve yanıt verebilirliği artırmak için Web Worker'ların ve Atomics API'nin gücünden yararlanabilirler. Paylaşılan bellek eş zamanlılığı karmaşıklık getirse de, aynı zamanda yoğun hesaplama gerektiren sorunları çözmek için güçlü bir araç sağlar. Paylaşılan bellek eş zamanlılığı, mesajlaşma ve aktör tabanlı eş zamanlılık arasında seçim yaparken performans ve karmaşıklık arasındaki dengeyi dikkatlice düşünün. JavaScript gelişmeye devam ettikçe, eş zamanlı programlama alanında daha fazla iyileştirme ve soyutlama beklenmektedir, bu da ölçeklenebilir ve performanslı uygulamalar oluşturmayı daha da kolaylaştıracaktır.

Eş zamanlı sistemler tasarlarken veri bütünlüğüne ve tutarlılığına öncelik vermeyi unutmayın. Eş zamanlı kodu test etmek ve hata ayıklamak zorlayıcı olabilir, bu nedenle kapsamlı test ve dikkatli tasarım çok önemlidir.